Software of the Month Club 1996 November/Software of the Month Club 1996 November.iso/pc/dos/edu/fracexp/create.ftf

Text File | 1996-06-17 | 9.1 KB | 260 lines

|rFractals|w are created by |giterating|w processes.
One of the simplest fractals is known as the |rvon Koch
curve.
|wTo create a von Koch curve, start with a line segment.
─────────
Divide this segment into three sections:
───  ───  ───
Now, replace the middle section with a triangle:
───/`\───
Break each of these 4 new segments into three
segments.
Replace the |ymiddle section|w of each segment with
|yanother triangle.|w

As the following graphics show, the line gets more
and more complex as you replace each existing
segment with a triangle.|r

@Press [ENTER] to see more iterations...
~koch1.pcx
~koch2.pcx
|wWhen iterated an infinite number of times,
The von Koch curve becomes both self similar and
infinite in detail, two properties of |rfractals.

@Press [ENTER] to create more elaborate fractals...
|wHere is a quick review of iterating functions.
|rREAL FUNCTIONS
|wlet |yf(x) |g= |yx²
|wlet |yx0 |g= |y2
       |yx1 |g= |yf(x0) |g= |r2² |g= |r4
       |yx2 |g= |yf(x1) |g= |yf(f(x0))    |g= |yf²(x0) |g= |r4²  |g= |r16
       |yx3 |g= |yf(x2) |g= |yf(f(f(x0))) |g= |yfÇ(x0) |g= |r16² |g= |r256

       |r2, 4, 16, 256, ··· |wis the orbit of |yx0 |g= |r2

|wlet |yf(x) |g= |rx²
|wlet |y  x0 |g= |r0.5
       |y  x1 |g= |rf(x0) |g= |y0.5²   |g= |r0.25
       |y  x2 |g= |rf(x1) |g= |yf²(x0) |g= |r0.25²  = |r0.125
       |y  x3 |g= |rf(x2) |g= |yfÇ(x0) |g= |r0.125² = |r0.0625

       |r0.5, 0.25, 0.125, 0.0625, ··· |wis the orbit of |yx0 |g= |r0.5

|wlet |yf(x) |g= |rx²
|wlet |yx0   |g= |r1
       |yx1 |g= |rf(x0) |g= |y1² = 1
       |yx2 |g= |rf(x1) |g= |yf²(x0)   |g= |r1² |g= |r1
       |yx3 |g= |rf(x2) |g= |yfÇ(x0) |g= |r1² |g= |r1

       |r1, 1, 1, 1, ··· |wis the orbit of |yx0 |g= |r1

@
This gives us the square rules for |rREAL NUMBERS|w:
|y1. |wif |yx0 |g> |r1|w, the orbit |yescapes to infinity
2. |wif |yx0 |g< |r1|w, the orbit |ygoes to 0
3. |wif |yx0 |g= |r1|w, the orbit |yremains at 1|w

Now, lets look at iterated |rcomplex|w functions.
Note, that |yz |wis a |rcomplex|w number, written
in the form |rz = x + yi|w
Look at this example of a complex iterated square² function:

|wlet |yf(z) |g= |yz²
|wlet   |yz0 |g= |r1 + 2i
       |yz1 |g= |yf(z0) |g= |r(1 + 2i)² |g= |r-3 + 4i
       |yz2 |g= |yf(z1) |g= |yf²(z0)    |g= |r(-3 + 4i)² |g= |r-7 - 24i
|w        :
          :
          |yz5 |g= |yf(z4) |g= |r-98248054847 - 116749235904i

       |r1 + 2i,  -3 + 4, -7 - 24i, ··· |wis the orbit for |yz0 |g= |r1 + 2i

|wlet |yf(z) |g= |yz²
|wlet   |yz0 |g= |r0.1 - 0.5i
       |yz1 |g= |yf(z0) |g= |r(0.1 - 0.5i)² |g= |r-0.24 - 0.1i
       |yz2 |g= |yf(z1) |g= |rf²(z0)      |g= |r(0.24 - 0.1i)² |g= |r0.476 + 0.48i
|w       :
        :
        |yz5 |g= |yf(z4) |g= |r0 + 0i

|r     0.1 - 0.5i, -0.24 - 0.1i, 0.476 + 0.48i, ··· |wis the orbit for |yz0 |g= |r0.1 - 0.5i

|wlet |yf(z) |g= |yz²
|wlet   |yz0 |g= |r0 - 1i
       |yz1 |g= |yf(z0) |g= |r(0 - 1i)² |g= |r-1
       |yz2 |g= |yf(z1) |g= |rf²(z0)  |g= |r(-1)² |g= |r1
       |w:
       :
       |yz5 |g= |yf(z4) |g= |r1

       |r0 - 1i, -1, 1, 1, 1, ··· |wis the orbit for |yz0 |g=|r 0 - 1i


|wBut how can you tell if an initial seed |yz0|w will
go to zero or infinity?

Here is how:
|rFirst|w, we must convert the complex number into a |rREAL|w
number so that we can use the |rREAL|w square rules.
|y│z0│|w is the distance on the complex plane from the origin
|r(0,0i)|w to the point |y (x0,y0i)|w. It is the |rABSOLUTE VALUE|w
of |yz0|w
It is a |rREAL|w number.

|y│z0│|w can be determined using the |rPythagorean theorem|w:
|y│z0│ |g= |y√(x0² + y0i²)
|w where x0 is the real part of the imaginary number,
and y0 is the complex part (z = a + bi, x0 = a, y0 = b)

|wThus, the square rules for a |rCOMPLEX |wseed |yz0 |wcan be written:
|y1. |wif |y│z0│|g >|r 1 |wthen the orbit will |yescape to infinity
2. |wif |y│z0│ |g< |r1 |wthen the orbit will |ygo to 0
3. |wif |y│z0│ |g= |r1 |wthen the orbit |ywill go to 1|r

@Press [ENTER] if you are hopelessly lost...
|wWhen we were talking about the |rvon Koch|w curve, we said
that all you did was repetitively replace segments with
triangles. This is known as a |gTRANSFORMATION.
|wTransformations can also be done using functions.
The function |rf(z) = z² + c|w |a(where c is a complex constant
for example 1.05 + 2.05i)|w is the basis of |gfractal geometry.|w

As we saw above, the function |rf(z) = z²|w followed three rules
when iterated - |rboring.|w But the function |rf(z) = z² + c|w
doesn't follow such rules! In fact, it is |rinfinitely complex
|wwhich you know by now is a property of |rfractals.

|wBut how do we |gSEE|w fractals?
To see the fractal described by |rf(z) = z² + c|w, we pick
a value of |yc|w, then we |giterate|w the |gfunction|r f(z)|w for
different seed values of |yz(0)|w and see if |rf(z)|w converges
on a number |a(such as 1 or 0)|w or |ggoes to infinity|w.
We pick values of |yz(0)|w on the Cartesian plane |a(X-Y plane)|w
so if we have a 10 x 10 plane, we plug in:

|gz(0) = -5 + 5i, z(0) = -5 + 4i, ..., z(0) = 5 + -5i|w

In other words, we |ycheck every point on the plane|w
and see |ywhat it does when iterated.|w

If it |gdoes not go to infinity|w, we color it |rblack|w,
the ones that |ggo to infinity|w, we color |rwhite|w.
Each picture is different depending on the value
of c, that complex constant.
The following is a fractal created with
|yc|g = |r-0.122 + 0.745i|r

@Press [ENTER] to view...
~bwfrac.pcx
|wAll those black points were places where the iterated
function |rconverged to a number.|w

If we want to get fancy, we can use |rcolor|w to
|genhance|w the fractal.

Instead of plotting the points that |yconverge|w, we
plot the points that go to infinity.
We use a |ydifferent color|w to represent the number of
iterations it took to reach infinity.
(e.g. 1 iteration is blue, 2 iterations is red, etc)
Look at the same fractal colored in.|r

@Press [ENTER] and select the first demo please...
\instruc.fee
|wThis type of fractal, where we pick an initial c value
is known as a |rJulia|w fractal, named for French
Mathematician |rGaston Julia.|r

@Press [ENTER] to see some sample BASIC code...
|wThe following is a simple |rBASIC|w program
that draws a |rJulia|w fractal by the above method:|g

10        INPUT "Real Part: ", CX
20        INPUT "Complex Part: ", CY
30        SCREEN 1
40        FOR A = 0 TO 100
50        FOR B = 0 TO 100
60                X0 = -2 + A / 25
70                Y0 = 2 - B / 25
80                I = 1
90                WHILE I < 20
100                        X1 = X0 * X0 - Y0 * Y0 + CX
110                        Y1 = 2 * X0 * Y0 + CY
120                        IF X1 * X1 + Y1 * Y1 > 4 THEN GOTO 180
130                        X0 = X1
140                        Y0 = Y1
150                        I = I + 1
160                WEND
170                GOTO 190
180                PSET (A, B), 5
190       NEXT B
200       NEXT A

|wTry it out yourself! Those 20 lines of code were what
started this whole thing!|r

@If that was all easy, press [ENTER]...
|wNow, an IBM researcher named |rBenoit Mandelbrot|w
decided it would be nice to see what the fractal
would look like that resulted from |yfixing|w z0
to be equal to |g0 + 0i|w instead of the points on
the plane, and using |yc|w to represent the points
on the plane.

The function is then iterated in a similar fashion.
The result is the famous |rMANDELBROT SET.

@Press [ENTER] and select the second demo to see it!
\instruc.fee
|wThere is only one possible true Mandelbrot set, since
|yz0|w is fixed at |g0 + 0i|w and |yc|w is always the points on
the plane.
But there are infinitely many |gJulia sets|w, since any
initial value of |yc|w can be used.
Be sure to check out the |rSHOW ME!|w example file
to see some great |gMandelbrot|w and |gjulia fractals.|r

@But what about those cool PLASMA fractals?
|wPlasma fractals are also created by |giterating
a procedure,|w but not a complex function as in
Mandelbrot and Julia fractals.

To create a |rPlasma|w fractal, the computer picks
|rrandom|w colors for the corners of a box.
It then subdivides this box into four smaller boxes.
The colors of these boxes are determined by an
average of the colors of their corners, plus a random
amount.
So now we have |gcolored boxes|w!

The program then divides each of these boxes
into 4 smaller ones, and colors them by the
same method, adding a random value each time.
The amount of randomness is determined by
the |rRoughness Constant|w that is input before
the plasma is drawn.

The program divides until each box is the size
of one dot (or |gpixel|w) on the screen.
You are left with an amazing fractal cloud.

If we correspond each color to a different
3-d height, these |ysmooth fractal clouds|w
are an amazingly real depiction of |rmountainous
landscapes. |wThe mountain on the title screen
was created with a plasma fractal!|r

@Press [ENTER] and select the third demo to see a PLAMSA fractal.
\instruc.fee
|wNow, check out a 3-D landscape
created with a plasma fractal!|r
@Press [ENTER]...
~fracmnt.pcx
|w
Be sure to read some of the other sections for more
information on ÅÉæÆôæös!|r

@Press [ENTER] to return to menu...